home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Linux / Kubuntu 8.10 / kubuntu-8.10-desktop-i386.iso / casper / filesystem.squashfs / usr / bin / run-mailcap < prev    next >
Text File  |  2008-06-19  |  16KB  |  549 lines

  1. #! /usr/bin/perl
  2. ###############################################################################
  3. #
  4. #  Run-Mailcap:  Run a program specified in the mailcap file based on a mime
  5. #  type.
  6. #
  7. #  Written by Brian White <bcwhite@pobox.com>
  8. #  This file has been placed in the public domain (the only true "free").
  9. #
  10. ###############################################################################
  11.  
  12.  
  13. $debug=0;
  14. $etcmimetyp="/etc/mime.types";
  15. $shrmimetyp="/usr/share/etc/mime.types";
  16. $locmimetyp="/usr/local/etc/mime.types";
  17. $usrmimetyp="$ENV{HOME}/.mime.types";
  18. $xtermprgrm="/usr/bin/x-terminal-emulator"; # xterm?
  19. $defmimetyp="application/octet-stream";
  20. $quotedsemi=chr(255);
  21. $quotedprct=chr(254);
  22. $retcode=0;
  23.  
  24.  
  25. %patterntypes =
  26. (
  27.  '(^|/)crontab[^/]+$'                           => 'text/x-crontab',            #'
  28.  '/man\d*/'                                     => 'application/x-troff-man',   #'
  29.  '\.\d[^\.]*$'                                  => 'application/x-troff-man',   #'
  30. );
  31.  
  32.  
  33.  
  34. sub Usage {
  35.     my($error) = @_;
  36.     print STDERR $error,"\n\n" if $error;
  37.  
  38.     print STDERR "Use: $0 <--action=VAL> [--debug] [MIME-TYPE:[ENCODING:]]FILE [...]\n\n";
  39.     print STDERR "Options:\n";
  40.     print STDERR "  action        specify what action to do on these files (default=view)\n";
  41.     print STDERR "  debug         be verbose about what's going on\n";
  42.     print STDERR "\n";
  43.     print STDERR "Mime-Type:\n";
  44.     print STDERR "  any standard mime type designation in the form <class>/<subtype> -- if\n";
  45.     print STDERR "  not specified, it will be determined from the filename extension\n\n";
  46.     print STDERR "Encoding:\n";
  47.     print STDERR "  how the file (and type) has been encoded (only \"gzip\", \"bzip\", \"bzip2\"\n";
  48.     print STDERR "  and \"compress\" are supported) -- if not specified, it will be determined\n";
  49.     print STDERR "  from the filename extension\n\n";
  50.  
  51.     exit ($error ? 1 : 0);
  52. }
  53.  
  54.  
  55.  
  56. sub EncodingForFile {
  57.     my($file) = @_;
  58.     my $encoding;
  59.  
  60.     if ($file =~ m/\.gz$/)  { $encoding = "gzip";       }
  61.     if ($file =~ m/\.bz$/)  { $encoding = "bzip";       }
  62.     if ($file =~ m/\.bz2$/) { $encoding = "bzip2";      }
  63.     if ($file =~ m/\.Z$/)   { $encoding = "compress";   }
  64.  
  65.     print STDERR " - file \"$file\" has encoding \"$encoding\"\n" if $debug && $encoding;
  66.  
  67.     return $encoding;
  68. }
  69.  
  70.  
  71.  
  72. sub ReadMimetypes {
  73.     my($file) = @_;
  74.  
  75.     return unless -r $file;
  76.  
  77.     print STDERR " - Reading mime.types file \"$file\"...\n" if $debug;
  78.     open(MIMETYPES,"<$file") || die "Error: could not read \"$file\" -- $!\n";
  79.     while (<MIMETYPES>) {
  80.         chomp;
  81.         s/\#.*$//;
  82.         next if (m/^\s*$/);
  83.  
  84.         $_=lc($_);
  85.         my($type,@exts) = split;
  86.  
  87.         foreach (@exts) {
  88.             $mimetypes{$_} = $type unless exists $mimetypes{$_};
  89.         }
  90.     }
  91.     close MIMETYPES;
  92. }
  93.  
  94.  
  95.  
  96. sub ReadMailcap {
  97.     my($file) = @_;
  98.     my $line = "";
  99.  
  100.     return unless -r $file;
  101.  
  102.     print STDERR " - Reading mailcap file \"$file\"...\n" if $debug;
  103.     open(MAILCAP,"<$file") || die "Error: could not read \"$file\" -- $!\n";
  104.     while (<MAILCAP>) {
  105.         chomp;
  106.         s/^\s+// if $line;
  107.         $line .= $_;
  108.         next unless $line;
  109.         if ($line =~ m/^\s*\#/) {
  110.             $line = "";
  111.             next;
  112.         }
  113.         if ($line =~ m/\\$/) {
  114.             $line =~ s/\\$//;
  115.         } else {
  116.             $line =~ s/\\;/$quotedsemi/go;
  117.             $line =~ s/\\%/$quotedprct/go;
  118.             push @mailcap,$line;
  119.             $line = "";
  120.         }
  121.     }
  122.     close MAILCAP;
  123. }
  124.  
  125.  
  126.  
  127. sub TempFile {
  128.     my($template) = @_;
  129.     my($cmd,$head,$tail,$tmpfile);
  130.     $template = "" unless (defined $template);
  131.  
  132.     ($head,$tail) = split(/%s/,$template,2);
  133.  
  134. #   $tmpfile = POSIX::tmpnam($name);
  135. #   unlink($tmpfile);
  136.  
  137.     $cmd  = "tempfile --mode=600";
  138.     $cmd .= " --prefix $head" if $head;
  139.     $cmd .= " --suffix $tail" if $tail;
  140.  
  141.     $tmpfile = `$cmd`;
  142.     chomp($tmpfile);
  143.  
  144. #   $tmpfile = $ENV{TMPDIR};
  145. #   $tmpfile = "/tmp" unless $tmpfile;
  146. #   $tmpfile.= "/$name";
  147. #   unlink($tmpfile);
  148.  
  149.     return $tmpfile;
  150. }
  151.  
  152.  
  153.  
  154. sub SaveStdin {
  155.     my($match) = @_;
  156.     my($tmpfile,$amt,$buf);
  157.  
  158.     $tmpfile = $1 if ($match =~ m/nametemplate=(.*?)\s*($|;)/);
  159.     $tmpfile = TempFile($tmpfile);
  160.     open(TMPFILE,">$tmpfile") || die "Error: could not write \"$tmpfile\" -- $!\n";
  161.     do {
  162.         $amt = read(STDIN,$buf,102400);
  163.         print TMPFILE $buf if $amt;
  164.     } while ($amt != 0);
  165.     close(TMPFILE);
  166.  
  167.     return $tmpfile;
  168. }
  169.  
  170.  
  171.  
  172. sub DecodeFile {
  173.     my($efile,$encoding,$action) = @_;
  174.     my($file,$res);
  175.  
  176.     $file = $efile;
  177.     $file =~ s!^.*/!!;          # remove leading directories
  178.     $file =~ s!\.[^\.]*$!!;     # remove encoding extension
  179.     $file =~ s!^\.?[^\.]*!%s!;  # replace name with placeholder
  180.     $file = undef if ($efile eq '-');
  181.     my $tmpfile = TempFile($file);
  182.  
  183.     print STDERR " - decoding \"$efile\" as \"$tmpfile\"\n" if $debug;
  184.  
  185. #   unlink($tmpfile); # should still be acceptable for "compose" output even if exists
  186.     return $tmpfile if (($efile ne '-' && ! -e $efile) || $action eq 'compose');
  187.  
  188.     if ($encoding eq "gzip") {
  189.         if ($efile eq '-') {
  190.             $res = system "gzip -d >\Q$tmpfile\E";
  191.         } else {
  192.             $res = system "gzip -dc \Q$efile\E >\Q$tmpfile\E";
  193.         }
  194.     } elsif ($encoding eq "bzip") {
  195.         if ($efile eq '-') {
  196.             $res = system "bzip -d >\Q$tmpfile\E";
  197.         } else {
  198.             $res = system "bzip -dc <\Q$efile\E >\Q$tmpfile\E";
  199.         }
  200.     } elsif ($encoding eq "bzip2") {
  201.         if ($efile eq '-') {
  202.             $res = system "bzip2 -d >\Q$tmpfile\E";
  203.         } else {
  204.             $res = system "bzip2 -dc <\Q$efile\E >\Q$tmpfile\E";
  205.         }
  206.     } elsif ($encoding eq "compress") {
  207.         if ($efile eq '-') {
  208.             $res = system "uncompress >\Q$tmpfile\E";
  209.         } else {
  210.             $res = system "uncompress <\Q$efile\E >\Q$tmpfile\E";
  211.         }
  212.     } else {
  213.         die "Fatal: unknown encoding \"$encoding\" at";
  214.     }
  215.  
  216.     $res = int($res/256);
  217.     if ($res != 0) {
  218.         print STDERR "Error: could not decode \"$efile\" -- $!\n";
  219.         $retcode = 2 if ($retcode < 2);
  220.         unlink($tmpfile);
  221.         return;
  222.     }
  223.  
  224. #   chmod 0600,$tmpfile; # done already by TempFile
  225.     return $tmpfile;
  226. }
  227.  
  228.  
  229.  
  230. sub EncodeFile {
  231.     my($dfile,$efile,$encoding) = @_;
  232.     my($res);
  233.  
  234.     print STDERR " - encoding \"$dfile\" as \"$efile\"\n";
  235.  
  236.     if ($encoding eq "gzip") {
  237.         if ($efile eq '-') {
  238.             $res = system "gzip -c \Q$dfile\E";
  239.         } else {
  240.             $res = system "gzip -c \Q$dfile\E >\Q$efile\E";
  241.         }
  242.     } elsif ($encoding eq "compress") {
  243.         if ($efile eq '-') {
  244.             $res = system "compress <\Q$dfile\E";
  245.         } else {
  246.             $res = system "compress <\Q$dfile\E >\Q$efile\E";
  247.         }
  248.     } else {
  249.         die "Fatal: unknown encoding \"$encoding\" at";
  250.     }
  251.  
  252.     $res = int($res/256);
  253.     if ($res != 0) {
  254.         print STDERR "Error: could not encode \"$efile\" (left as \"$dfile\")\n";
  255.         $retcode = 2 if ($retcode < 2);
  256.         return;
  257.     }
  258.  
  259.     return $dfile;
  260. }
  261.  
  262.  
  263.  
  264. sub ExtensionMimetype {
  265.     my($ext) = @_;
  266.     my($typ);
  267.  
  268.     unless ($donemimetypes) {
  269.         ReadMimetypes($usrmimetyp);
  270.         ReadMimetypes($locmimetyp);
  271.         ReadMimetypes($shrmimetyp);
  272.         ReadMimetypes($etcmimetyp);
  273.         $donemimetypes = 1;
  274.     }
  275.  
  276.     $typ = $mimetypes{lc($ext)};
  277.  
  278.     print STDERR " - extension \"$ext\" maps to mime-type \"$typ\"\n" if $debug;
  279.     return $typ;
  280. }
  281.  
  282.  
  283.  
  284. sub PatternMimetype {
  285.     my($file) = @_;
  286.     my($key,$val);
  287.  
  288.     while (($key,$val) = each %patterntypes) {
  289.         if ($file =~ m!$key!i) {
  290.             print STDERR " - file \"$file\" maps to mime-type \"$val\"\n" if $debug;
  291.             return $val;
  292.         }
  293.     }
  294.  
  295.     print STDERR " - file \"$file\" does not conform to any known pattern\n" if $debug;
  296.     return;
  297. }
  298.  
  299.  
  300.  
  301. sub FileMimetype {
  302.     my($file) = @_;
  303.     my($ext)  = ($file =~ m!\.([^/\.]+)$!);
  304.  
  305.     my $type;
  306.  
  307.     $type = ExtensionMimetype($ext) if $ext;
  308.     $type = PatternMimetype($file) unless $type;
  309.  
  310.     return $type;
  311. }
  312.  
  313.  
  314.  
  315. @files = ();
  316. foreach (@ARGV) {
  317.     print STDERR " - parsing parameter \"$_\"\n" if $debug;
  318.     if (m!^(-h|--help)$!) {
  319.         Usage();
  320.         exit(0);
  321.     } elsif (m!^--(.*?)=(.*)$!) {
  322.         print STDERR "Warning: definition of \"$1=$2\" overrides value \"${$1}\"\n" if ($ {$1} && $ {$1} != $2);
  323.         $ {$1}=$2;
  324.     } elsif (m!^--(.*?)$!) {
  325.         print STDERR "Warning: definition of \"$1=$2\" overrides value \"${$1}\"\n" if ($ {$1} && $ {$1} != 1);
  326.         $ {$1}=1;
  327.     } elsif (m!^[^/:]+/[^/:]+:[^/:]+:!) {
  328.         push @files,$_;
  329.     } elsif (m!^([^/:]+/[^/:]+):(.*)! && ! -e $_) {
  330.         my $file = $_;
  331.         my $type = $1;
  332.         my $file = $2;
  333.         my $code = EncodingForFile($file);
  334.         push @files,"${type}:${code}:${file}";
  335.         print STDERR " - file \"$file\" does not exist -- assuming mime-type specification of \"${type}\"\n" if $debug;
  336.     } else {
  337.         my $file = $_;
  338.         my $code = EncodingForFile($file);
  339.         my $type;
  340.         if ($code) {
  341.             my $efile = $file;
  342.             $efile =~ s/\.[^\.]+$//;
  343.             $type = FileMimetype($efile);
  344.         } else {
  345.             $type = FileMimetype($file);
  346.         }
  347.         if ($type) {
  348.             push @files,"${type}:${code}:${file}";
  349.         } else {
  350.             print STDERR "Warning: unknown mime-type for \"$file\" -- using \"$defmimetyp\"\n";
  351.             push @files,"${defmimetyp}:${code}:${file}";
  352.         }
  353.     }
  354. }
  355.  
  356. unless ($action) {
  357.        if ($0 =~ m!(^|/)view$!)     { $action="view";   }
  358.     elsif ($0 =~ m!(^|/)see$!)      { $action="view";   }
  359.     elsif ($0 =~ m!(^|/)edit$!)     { $action="edit";   }
  360.     elsif ($0 =~ m!(^|/)change$!)   { $action="edit";   }
  361.     elsif ($0 =~ m!(^|/)compose$!)  { $action="compose";}
  362.     elsif ($0 =~ m!(^|/)print$!)    { $action="print";  }
  363.     elsif ($0 =~ m!(^|/)create$!)   { $action="compose";}
  364.     else                            { $action="view";   }
  365. }
  366.  
  367.  
  368. $mailcaps = $ENV{MAILCAPS};
  369. $mailcaps = "$ENV{HOME}/.mailcap:/etc/mailcap:/usr/local/etc/mailcap:/usr/share/etc/mailcap:/usr/etc/mailcap" unless $mailcaps;
  370. foreach (split(/:/,$mailcaps)) {
  371.     ReadMailcap($_);
  372. }
  373.  
  374. foreach (@files) {
  375.     my($type,$code,$file) = m/^(.*?):(.*?):(.*)$/;
  376.     print STDERR "Processing file \"$file\" of type \"$type\" (encoding=",$code?$code:"none",")...\n" if $debug;
  377.  
  378.     if ($file ne '-') {
  379.         if ($action eq 'compose' || $action eq 'edit') {
  380.             if (-e $file) {
  381.                 if (! -w $file) {
  382.                     print STDERR "Error: no write permission for file \"$file\"\n";
  383.                     $retcode = 2 if ($retcode < 2);
  384.                     next;
  385.                 }
  386.             } else {
  387.                 if (open(TEST,">$file")) {
  388.                     close(TEST);
  389.                     unlink($file);
  390.                 } else {
  391.                     print STDERR "Error: no write permission for file \"$file\"\n";
  392.                     $retcode = 2 if ($retcode < 2);
  393.                     next;
  394.                 }
  395.             }
  396.         } else {
  397.             if (! -e $file) {
  398.                 print STDERR "Error: no such file \"$file\"\n";
  399.                 $retcode = 2 if ($retcode < 2);
  400.                 next;
  401.             }
  402.             if (! -r $file) {
  403.                 print STDERR "Error: no read permission for file \"$file\"\n";
  404.                 $retcode = 2 if ($retcode < 2);
  405.                 next;
  406.             }
  407.         }
  408.     }
  409.  
  410.     my(@matches,$entry,$res,$efile);
  411.     if ($code) {
  412.         $efile = $file;
  413.         $file  = DecodeFile($efile,$code,$action);
  414.         next unless $file;
  415.     }
  416.  
  417.     foreach $entry (@mailcap) {
  418.         $entry =~ m/^(.*?)\s*;/;
  419.         $_ = "\Q$1\E"; s/\\\*/\.\*/g;
  420.         push @matches,$entry if ($type =~ m!^$_$!i);
  421.     }
  422.     @matches = grep(/\Q$action\E=/,@matches) unless $action eq "view";
  423.  
  424.     my $done=0;
  425.     my $fail=0;
  426.     foreach $match (@matches) {
  427.         my $comm;
  428.         print STDERR " - checking mailcap entry \"$match\"\n" if $debug;
  429.         if ($action eq "view") {
  430.             ($comm) = ($match =~ m/^.*?;\s*(.*?)\s*($|;)/);
  431.         } else {
  432.             ($comm) = ($match =~ m/\Q$action\E=(.*?)\s*($|;)/);
  433.         }
  434.         next if (!$comm || $comm =~ m!(^|/)false$!i);
  435.         print STDERR " - program to execute: $comm\n" if $debug;
  436.  
  437.         if ($match =~ m/;\s*test=(.*?)\s*($|;)/) {
  438.             my $test;
  439.             print STDERR " - running test: $1 " if $debug;
  440.             $test   = system "$1 >/dev/null 2>&1";
  441.             $test >>= 8;
  442.             print STDERR " (result=$test=",($test!=0?"false":"true"),")\n" if $debug;
  443.             if ($test) {
  444.                 $fail++;
  445.                 next;
  446.             }
  447.         }
  448.  
  449.         my($tmpfile,$tmplink);
  450.         if ($action ne 'print' && $match =~ m/;\s*needsterminal\s*($|;)/ && ! -t STDOUT) {
  451.             if ($ENV{DISPLAY}) {
  452.                 $comm = "$xtermprgrm -T '$file ($type)' -e $0 --action=$action '${type}:%s'";
  453.             } else {
  454.                 print STDERR " - no terminal available for rule (needsterminal)\n" if $debug;
  455.                 $fail++;
  456.                 next;
  457.             }
  458.         } elsif ($action eq 'view' && $match =~ m/;\s*copiousoutput\s*($|;)/) {
  459.             $comm .= " | $0 --action=$action text/plain:-";
  460.         }
  461.  
  462.         if ($file ne "-") {
  463.             if ($comm =~ m/[^%]%s/) {
  464.                 if ($file =~ m![^ a-z0-9,.:/@%^+=_-]!i) {
  465.                     $match =~ m/nametemplate=(.*?)\s*($|;)/;
  466.                     my $prefix = $1;
  467.                     my $linked = 0;
  468.                     while (!$linked) {
  469.                         $tmplink = TempFile($prefix);
  470.                         unlink($tmplink);
  471.                         if ($file =~ m!^/!) {
  472.                             $linked = symlink($file,$tmplink);
  473.                         } else {
  474.                             my $pwd = `/bin/pwd`;
  475.                             chomp($pwd);
  476.                             $linked = symlink("$pwd/$file",$tmplink);
  477.                         }
  478.                     }
  479.                     print STDERR " - filename contains shell meta-characters; aliased to '$tmplink'\n" if $debug;
  480.                     $comm =~ s/([^%])%s/$1$tmplink/g;
  481.                 } else {
  482.                     $comm =~ s/([^%])%s/$1$file/g;
  483.                 }
  484.             } else {
  485.                 if ($comm =~ m/\|/) {
  486.                     $comm =~ s/\|/<\Q$file\E \|/;
  487.                 } else {
  488.                     $comm .= " <\Q$file\E";
  489.                 }
  490.                 if ($action eq 'edit' || $action eq 'compose') {
  491.                     $comm .= " >\Q$file\E";
  492.                 }
  493.             }
  494.         } else {
  495.             if ($comm =~ m/[^%]%s/) {
  496.                 $tmpfile = SaveStdin($match);
  497.                 $comm =~ s/([^%])%s/$1$tmpfile/g;
  498.             } else {
  499.                 # no name means same as "-"... read from stdin
  500.             }
  501.         }
  502.  
  503.         $comm =~ s!([^%])%t!$1$type!g;
  504.         $comm =~ s!([^%])%F!$1!g;
  505.         $comm =~ s!%{(.*?)}!$_="'$ENV{$1}'";s/\`//g;s/\'\'//g;$_!ge;
  506.         $comm =~ s!\\(.)!$1!g;
  507.         $comm =~ s!\'\'!\'!g;
  508.         $comm =~ s!$quotedsemi!;!go;
  509.         $comm =~ s!$quotedprct!%!go;
  510.  
  511.         print STDERR " - executing: $comm\n" if $debug;
  512.         $res = system $comm;
  513.         $res = int($res/256);
  514.         if ($res != 0) {
  515.             print STDERR "Warning: program returned non-zero exit code \#$res\n";
  516.             $retcode = $res;
  517.         }
  518.         $done=1;
  519.         unlink $tmpfile if $tmpfile;
  520.         unlink $tmplink if $tmplink;
  521.         last;
  522.     }
  523.  
  524.     if (!$done) {
  525.         if ($fail) {
  526.             print STDERR "Error: no \"$action\" rule for type \"$type\" passed its test case\n";
  527.             print STDERR "       (for more information, add \"--debug=1\" on the command line)\n";
  528.             $retcode = 3 if ($retcode < 3);
  529.         } else {
  530.             print STDERR "Error: no \"$action\" mailcap rules found for type \"$type\"\n";
  531.             $retcode = 3 if ($retcode < 3);
  532.         }
  533.         unlink $file if $code;
  534.         $retcode = 1 unless $retcode;
  535.         next;
  536.     }
  537.  
  538.     if ($code) {
  539.         if ($action eq 'edit' || $action eq 'compose') {
  540.             my $file = EncodeFile($file,$efile,$code);
  541.             unlink $file if $file;
  542.         } else {
  543.             unlink $file;
  544.         }
  545.     }
  546. }
  547.  
  548. exit($retcode);
  549.